<template>
	<PageLayout>
		<view class="bookshelf-every">
			<view class="header">
				<text>书架</text>
				<text class="iconfont icon-tianjia1" style="font-size: 30px;margin-left: 30px;"
					@click="handleAddBook"></text>
			</view>
			<scroll-view  scroll-y="true" class="book-list" @scrolltoupper="upper"
				@scrolltolower="lower" @scroll="scroll">
				<view class="book-grid-container">
					<view v-for="(book, index) in books" :key="index" class="book-item" @click="handleBookClick(book)" @longpress="handleLongPress(book)">
						<image :src="book.cover" mode="aspectFill" class="book-cover"></image>
						<text class="book-title">{{ book.title }}</text>
					</view>
				</view>
			</scroll-view>
		</view>
	</PageLayout>
</template>

<script setup>
	import {
		ref,
		onMounted
	} from 'vue';
	import {
		useNovelStore
	} from '../../common/novel/novel.js';
	import {
		useTextLayoutStore
	} from '../../common/novel/textLayout.js';

	const store = useNovelStore();
	const textLayoutStore = useTextLayoutStore();
	const books = ref([]);

	// 加载书架数据
	const loadBookshelf = async () => {
		try {
			plus.io.resolveLocalFileSystemURL('_doc/novels', (entry) => {
				const reader = entry.createReader();
				reader.readEntries((entries) => {
					books.value = [];
					entries.forEach((fileEntry) => {
						if (fileEntry.isFile && fileEntry.name.toLowerCase().endsWith(
								'.txt')) {
							books.value.push({
								title: fileEntry.name.replace('.txt', ''),
								path: '_doc/novels/' + fileEntry.name,
								cover: '/static/box/1.png'
							});
						}
					});
					saveBookshelf();
					console.log('书架数据加载完成:', books.value);
				}, (error) => {
					console.error('读取目录失败:', error);
					uni.showToast({
						title: '读取书架失败',
						icon: 'none'
					});
				});
			}, (error) => {
				console.error('访问novels目录失败:', error);
				books.value = [];
				saveBookshelf();
			});
		} catch (error) {
			console.error('加载书架数据失败:', error);
			uni.showToast({
				title: '加载书架失败',
				icon: 'none'
			});
		}
	};

	// 保存书架数据
	const saveBookshelf = () => {
		try {
			uni.setStorageSync('bookshelf', books.value);
			console.log('书架数据保存成功:', books.value);
		} catch (error) {
			console.error('保存书架数据失败:', error);
		}
	};

	// 处理添加书籍
	const handleAddBook = async () => {
		// #ifdef APP-PLUS
		try {
			console.log('开始添加书籍');
			// 检查并请求权限
			const checkAndRequestPermission = () => {
				return new Promise((resolve, reject) => {
					// 针对Android 11(API 30)及以上版本，请求MANAGE_EXTERNAL_STORAGE权限
					let isAndroid11OrAbove = false;
					try {
						const Build = plus.android.importClass('android.os.Build');
						const VERSION = plus.android.importClass('android.os.Build$VERSION');
						isAndroid11OrAbove = VERSION.SDK_INT >= 30; // Android 11 是 API 30
						console.log('Android版本:', VERSION.SDK_INT);
					} catch (err) {
						console.error('检查Android版本失败:', err);
					}

					if (isAndroid11OrAbove) {
						// 对于Android 11+，需要请求MANAGE_EXTERNAL_STORAGE权限
						try {
							const Environment = plus.android.importClass('android.os.Environment');
							const Intent = plus.android.importClass('android.content.Intent');
							const Settings = plus.android.importClass('android.provider.Settings');
							const Uri = plus.android.importClass('android.net.Uri');
							const context = plus.android.runtimeMainActivity();
							
							// 检查是否已有管理所有文件的权限
							const hasAllFilesPermission = Environment.isExternalStorageManager();
							console.log('是否有管理所有文件权限:', hasAllFilesPermission);
							
							if (hasAllFilesPermission) {
								// 已有权限，直接返回成功
								resolve(true);
								return;
							}
							
							// 显示引导用户去系统设置开启权限的对话框
							uni.showModal({
								title: '需要文件访问权限',
								content: '本应用需要"管理所有文件"权限才能添加小说。点击确定将跳转到系统设置，请在设置中允许权限。',
								success: function(res) {
									if (res.confirm) {
										// 跳转到系统设置页面
										try {
											const intent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
											const uri = Uri.parse('package:' + context.getPackageName());
											intent.setData(uri);
											context.startActivity(intent);
											
											// 由于跳转到设置页面后无法自动检测权限状态变化，这里返回false
											// 用户需要手动再次点击添加书籍按钮
											uni.showToast({
												title: '请在设置中开启权限后，返回应用重新添加书籍',
												icon: 'none',
												duration: 3000
											});
											resolve(false);
										} catch (e) {
											console.error('跳转设置页面失败:', e);
											uni.showToast({
												title: '跳转设置页面失败，请手动前往设置开启权限',
												icon: 'none',
												duration: 3000
											});
											resolve(false);
										}
									} else {
										uni.showToast({
											title: '您拒绝了权限请求，无法添加书籍',
											icon: 'none',
											duration: 2000
										});
										resolve(false);
									}
								}
							});
						} catch (err) {
							console.error('处理Android 11+权限失败:', err);
							uni.showToast({
								title: '权限请求失败: ' + (err.message || JSON.stringify(err)),
								icon: 'none',
								duration: 3000
							});
							resolve(false);
						}
					} else {
						// 对于Android 10及以下，使用传统权限请求
						plus.android.requestPermissions(
							['android.permission.READ_EXTERNAL_STORAGE',
								'android.permission.WRITE_EXTERNAL_STORAGE'
							],
							function(resultObj) {
								console.log('权限请求结果:', resultObj);
								let granted = resultObj.granted && resultObj.granted.length > 0;
								if (!granted) {
									uni.showModal({
										title: '需要存储权限',
										content: '请前往系统设置，找到本应用，开启存储权限。',
										confirmText: '去设置',
										success: function(res) {
											if (res.confirm) {
												// 尝试打开应用设置页面
												try {
													const Intent = plus.android.importClass('android.content.Intent');
													const Settings = plus.android.importClass('android.provider.Settings');
													const Uri = plus.android.importClass('android.net.Uri');
													const mainActivity = plus.android.runtimeMainActivity();
													const packageName = mainActivity.getPackageName();
													
													const intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
													const uri = Uri.parse('package:' + packageName);
													intent.setData(uri);
													mainActivity.startActivity(intent);
												} catch (e) {
													console.error('打开设置页面失败:', e);
													uni.showToast({
														title: '打开设置页面失败，请手动前往设置',
														icon: 'none',
														duration: 3000
													});
												}
											}
										}
									});
								}
								resolve(granted);
							},
							function(error) {
								console.error('权限请求失败:', error);
								uni.showToast({
									title: '权限请求失败: ' + (error.message || JSON.stringify(error)),
									icon: 'none',
									duration: 3000
								});
								reject(error);
							}
						);
					}
				});
			};

			// 不再需要预先检查普通存储权限，直接使用修改后的检查函数
			const hasPermission = await checkAndRequestPermission();
			if (!hasPermission) {
				console.log('未获取到所需权限');
				return;
			}

			// 确保目标目录存在
			const ensureDirectory = () => {
				return new Promise((resolve, reject) => {
					plus.io.resolveLocalFileSystemURL('_www/static', (staticEntry) => {
						staticEntry.getDirectory('novels', {
							create: true
						}, (novelsEntry) => {
							resolve(novelsEntry);
						}, (error) => {
							console.error('创建novels目录失败:', error);
							uni.showToast({
								title: '创建novels目录失败: ' + (error.message || JSON.stringify(error)),
								icon: 'none',
								duration: 3000
							});
							reject(error);
						});
					}, (error) => {
						console.error('访问static目录失败:', error);
						uni.showToast({
							title: '访问static目录失败: ' + (error.message || JSON.stringify(error)),
							icon: 'none',
							duration: 3000
						});
						reject(error);
					});
				});
			};

			try {
				await ensureDirectory();
				uni.showToast({
					title: '目录检查成功，请选择TXT文件',
					icon: 'none',
					duration: 2000
				});
			} catch (dirError) {
				console.error('目录创建失败:', dirError);
				return;
			}

			// 选择文件
			const main = plus.android.runtimeMainActivity();
			const Intent = plus.android.importClass('android.content.Intent');
			const intent = new Intent(Intent.ACTION_GET_CONTENT);
			intent.setType('text/plain');
			intent.addCategory(Intent.CATEGORY_OPENABLE);

			// 启动文件选择器
			try {
				main.startActivityForResult(intent, 1);
			} catch (activityError) {
				uni.showToast({
					title: '启动文件选择器失败: ' + (activityError.message || JSON.stringify(activityError)),
					icon: 'none',
					duration: 3000
				});
				return;
			}

			// 监听选择结果
			main.onActivityResult = function(requestCode, resultCode, data) {
				if (requestCode === 1 && resultCode === -1 && data) {
					try {
						const InputStreamReader = plus.android.importClass('java.io.InputStreamReader');
						const BufferedReader = plus.android.importClass('java.io.BufferedReader');
						const StringBuilder = plus.android.importClass('java.lang.StringBuilder');
						const main = plus.android.runtimeMainActivity();
						const uri = data.getData();
						console.log('获取到的uri:', uri);
						const contentResolver = main.getContentResolver();
						console.log('contentResolver:', contentResolver);
						uni.showLoading({
							title: '正在导入小说...'
						});

						// 获取文件名
						let displayName = '未知文件.txt';
						try {
							// 先直接从URI尝试获取路径
							const uriString = uri.toString();
							console.log('URI完整字符串:', uriString);
							
							// 尝试使用getPath方法
							try {
								const uriPath = uri.getPath();
								console.log('URI getPath结果:', uriPath);
								if (uriPath && uriPath.length > 0) {
									const lastSlash = uriPath.lastIndexOf('/');
									if (lastSlash !== -1 && lastSlash < uriPath.length - 1) {
										const pathName = uriPath.substring(lastSlash + 1);
										console.log('从getPath提取的文件名:', pathName);
										if (pathName && pathName.length > 0) {
											displayName = decodeURIComponent(pathName);
										}
									}
								}
							} catch (pathErr) {
								console.error('获取URI路径失败:', pathErr);
							}
							
							// 确保DocumentFile类可用，否则使用其他方法获取文件名
							const DocumentFile = plus.android.importClass('androidx.documentfile.provider.DocumentFile');
							if (DocumentFile) {
								console.log('DocumentFile类导入成功');
								const documentFile = DocumentFile.fromSingleUri(main, uri);
								console.log('documentFile对象:', documentFile);
								
								if (documentFile) {
									const docFileName = documentFile.getName();
									console.log('DocumentFile.getName()结果:', docFileName);
									if (docFileName && docFileName.length > 0) {
										displayName = docFileName;
									}
								} else {
									console.log('documentFile为null，尝试使用uri获取文件名');
								}
							} else {
								console.log('DocumentFile类导入失败');
							}
							
							// 如果上面的方法都失败，尝试使用ContentResolver
							if (displayName === '未知文件.txt') {
								console.log('尝试使用ContentResolver获取文件名');
								try {
									// 导入需要的类
									const Cursor = plus.android.importClass('android.database.Cursor');
									const OpenableColumns = plus.android.importClass('android.provider.OpenableColumns');
									
									// 查询文件信息
									const cursor = contentResolver.query(uri, null, null, null, null);
									console.log('查询cursor:', cursor);
									
									if (cursor && cursor.moveToFirst()) {
										const nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
										console.log('nameIndex:', nameIndex);
										
										if (nameIndex !== -1) {
											const cursorName = cursor.getString(nameIndex);
											console.log('cursor获取的文件名:', cursorName);
											if (cursorName && cursorName.length > 0) {
												displayName = cursorName;
											}
										}
										cursor.close();
									} else {
										console.log('cursor为空或无法移动到第一行');
									}
								} catch (cursorErr) {
									console.error('使用ContentResolver获取文件名失败:', cursorErr);
								}
							}
							
							// 最后尝试从URI字符串解析
							if (displayName === '未知文件.txt') {
								// 从uri字符串中提取文件名
								const segments = uriString.split('/');
								console.log('URI分段:', segments);
								
								if (segments.length > 0) {
									let lastSegment = segments[segments.length - 1];
									console.log('最后一段:', lastSegment);
									
									// 处理查询参数
									const queryParamIndex = lastSegment.indexOf('?');
									if (queryParamIndex !== -1) {
										lastSegment = lastSegment.substring(0, queryParamIndex);
									}
									
									if (lastSegment && lastSegment.length > 0) {
										try {
											const decodedSegment = decodeURIComponent(lastSegment);
											console.log('解码后的最后一段:', decodedSegment);
											if (decodedSegment && decodedSegment.length > 0) {
												displayName = decodedSegment;
											}
										} catch (decodeErr) {
											console.error('解码URI段失败:', decodeErr);
										}
									}
								}
							}
							
							// 最后一种方法：尝试获取选择的文件的最后修改时间作为名称的一部分
							if (displayName === '未知文件.txt') {
								try {
									const currentTime = new Date();
									const timeString = currentTime.getFullYear() + 
										'-' + (currentTime.getMonth() + 1) + 
										'-' + currentTime.getDate() + 
										'_' + currentTime.getHours() + 
										'-' + currentTime.getMinutes();
									displayName = '导入的小说_' + timeString + '.txt';
								} catch (timeErr) {
									console.error('生成时间文件名失败:', timeErr);
								}
							}
						} catch (docFileErr) {
							console.error('获取文件名主流程出错:', docFileErr);
							// 生成带时间戳的默认名称
							try {
								const currentTime = new Date();
								const timeString = currentTime.getFullYear() + 
									'-' + (currentTime.getMonth() + 1) + 
									'-' + currentTime.getDate() + 
									'_' + currentTime.getHours() + 
									'-' + currentTime.getMinutes();
								displayName = '导入的小说_' + timeString + '.txt';
							} catch (e) {
								// 保持默认名称
							}
						}
						
						// 确保displayName是txt文件且没有非法字符
						if (!displayName.toLowerCase().endsWith('.txt')) {
							displayName += '.txt';
						}
						
						// 替换文件名中的非法字符
						displayName = displayName.replace(/[\\/:*?"<>|]/g, '_');
						
						console.log('最终使用的文件名:', displayName);
						uni.showToast({
							title: '正在读取: ' + displayName,
							icon: 'none',
							duration: 1500
						});

						// 用 plus.android.invoke 调用 openInputStream
						let inputStream;
						try {
							inputStream = plus.android.invoke(contentResolver, "openInputStream", uri);
							console.log('inputStream:', inputStream);
						} catch (err) {
							console.error('openInputStream失败:', err);
							uni.hideLoading();
							uni.showToast({
								title: 'openInputStream失败: ' + (err.message || JSON.stringify(err)),
								icon: 'none',
								duration: 3000
							});
							throw err;
						}

						// 性能优化：使用更大的缓冲区和批处理方式读取文件
						try {
							uni.showLoading({
								title: '正在读取文件...',
								mask: true
							});
							
							// 读取文件大小（移除可能不兼容的方法）
							let fileSize = 0;
							// 不再尝试获取文件大小，避免API兼容性问题
							
							// 预估文件读取进度
							const updateInterval = 500; // 更新进度的间隔（毫秒）
							let lastUpdateTime = Date.now();
							let showProgress = true; // 总是显示进度
							
							// 使用更高效的读取方式
							const InputStreamReader = plus.android.importClass('java.io.InputStreamReader');
							const BufferedReader = plus.android.importClass('java.io.BufferedReader');
							const StringBuilder = plus.android.importClass('java.lang.StringBuilder');
							
							// 创建更大的缓冲区读取器
							const reader = new BufferedReader(new InputStreamReader(inputStream, 'utf-8'), 16384); // 16KB缓冲区
							const stringBuilder = new StringBuilder(1024 * 1024); // 预分配1MB
							
							// 批量读取
							const maxBatchLines = 5000; // 每批次读取的最大行数
							let line;
							let lineCount = 0;
							let batchCount = 0;
							let bytesRead = 0;
							let batchStartTime = Date.now();
							
							while ((line = reader.readLine()) != null) {
								stringBuilder.append(line);
								stringBuilder.append('\n');
								lineCount++;
								
								// 每行估算字节数(不使用length()方法，避免错误)
								bytesRead += line.toString().length + 1; // 加1是换行符
								
								// 每批次处理
								if (lineCount % maxBatchLines === 0) {
									batchCount++;
									
									// 更新加载提示和进度
									const now = Date.now();
									if (showProgress && now - lastUpdateTime > updateInterval) {
										lastUpdateTime = now;
										
										// 使用行数作为进度指示
										const progressText = lineCount + '行';
										
										// 计算读取速度
										const elapsedSec = Math.max(0.1, (now - batchStartTime) / 1000);
										const linesPerSec = Math.floor(maxBatchLines / elapsedSec);
										
										uni.showLoading({
											title: '读取中: ' + progressText + ' (' + linesPerSec + '行/秒)',
											mask: true
										});
										
										// 允许UI更新
										setTimeout(() => {
											batchStartTime = Date.now();
										}, 0);
									}
								}
							}
							
							// 关闭资源
							plus.android.invoke(reader, "close");
							plus.android.invoke(inputStream, "close");
							
							const fileContent = stringBuilder.toString();
							console.log('总共读取行数:', lineCount, '总批次:', batchCount);
							uni.showToast({
								title: '读取完成: ' + lineCount + '行',
								icon: 'success',
								duration: 1500
							});
							
							if (!fileContent || fileContent.length < 10) {
								uni.hideLoading();
								uni.showToast({
									title: '文件内容为空或太小，请检查文件',
									icon: 'none',
									duration: 3000
								});
								return;
							}
							
							// 保存到本地
							plus.io.resolveLocalFileSystemURL('_doc', (docEntry) => {
								docEntry.getDirectory('novels', {
									create: true
								}, (novelsEntry) => {
									novelsEntry.getFile(displayName, {
										create: true
									}, (fileEntry) => {
										console.log('fileEntry.fullPath:', fileEntry
											.fullPath);
										console.log('准备写入文件:', displayName);
										fileEntry.createWriter((writer) => {
											console.log('已获取writer，准备写入...');
											writer.onwrite = function() {
												uni.hideLoading();
												console.log('文件写入成功');
												uni.showToast({
													title: '添加成功: ' + displayName,
													icon: 'success',
													duration: 2000
												});
												loadBookshelf();
											};
											writer.onerror = function(error) {
												uni.hideLoading();
												console.error('文件写入失败:', error,
													error.target && error
													.target.error);
												uni.showToast({
													title: '写入失败: ' + ((error && error.target && error.target.error) || JSON.stringify(error)),
													icon: 'none',
													duration: 3000
												});
											};
											try {
												writer.write(fileContent);
												console.log('write方法已调用');
											} catch (err) {
												uni.hideLoading();
												console.error('write方法异常:', err);
												uni.showToast({
													title: '写入异常: ' + (err.message || JSON.stringify(err)),
													icon: 'none',
													duration: 3000
												});
											}
										}, (writerErr) => {
											uni.hideLoading();
											uni.showToast({
												title: '创建写入器失败: ' + (writerErr.message || JSON.stringify(writerErr)),
												icon: 'none',
												duration: 3000
											});
										});
									}, (fileErr) => {
										uni.hideLoading();
										uni.showToast({
											title: '创建文件失败: ' + (fileErr.message || JSON.stringify(fileErr)),
											icon: 'none',
											duration: 3000
										});
									});
								}, (dirErr) => {
									uni.hideLoading();
									uni.showToast({
										title: '创建novels目录失败: ' + (dirErr.message || JSON.stringify(dirErr)),
										icon: 'none',
										duration: 3000
									});
								});
							}, (docErr) => {
								uni.hideLoading();
								uni.showToast({
									title: '访问_doc目录失败: ' + (docErr.message || JSON.stringify(docErr)),
									icon: 'none',
									duration: 3000
								});
							});
						} catch (e) {
							uni.hideLoading();
							console.error('文件读取失败详细信息:', e);
							uni.showToast({
								title: '文件处理失败: ' + (e.message || JSON.stringify(e)),
								icon: 'none',
								duration: 3000
							});
						}
					} catch (e) {
						uni.hideLoading();
						console.error('文件读取失败详细信息:', e);
						uni.showToast({
							title: '文件处理失败: ' + (e.message || JSON.stringify(e)),
							icon: 'none',
							duration: 3000
						});
					}
				} else if (requestCode === 1) {
					let reason = resultCode === 0 ? '用户取消选择' : '未知原因';
					uni.showToast({
						title: '未选择文件: ' + reason,
						icon: 'none',
						duration: 2000
					});
				}
			};
		} catch (error) {
			console.error('添加书籍失败:', error);
			uni.showToast({
				title: '添加书籍失败: ' + (error.message || JSON.stringify(error)),
				icon: 'none',
				duration: 3000
			});
		}
		// #endif

		// #ifdef H5
		uni.showToast({
			title: 'H5环境暂不支持此功能',
			icon: 'none'
		});
		// #endif
	};

	// 处理书籍点击
	const handleBookClick = (book) => {
		console.log('点击书籍:', book);
		uni.navigateTo({
			url: `/pages/read/read?path=${encodeURIComponent(book.path)}`
		});
	};
	
	// 处理长按删除书籍
	const handleLongPress = (book) => {
		console.log('长按书籍:', book);
		uni.showModal({
			title: '删除书籍',
			content: `确定要删除《${book.title}》吗？`,
			success: (res) => {
				if (res.confirm) {
					deleteBook(book);
				}
			}
		});
	};
	
	// 删除书籍
	const deleteBook = (book) => {
		try {
			// 从文件系统中删除书籍文件
			plus.io.resolveLocalFileSystemURL(book.path, (entry) => {
				entry.remove(() => {
					console.log('文件删除成功:', book.path);
					// 从书架数组中移除该书籍
					const index = books.value.findIndex(item => item.path === book.path);
					if (index !== -1) {
						books.value.splice(index, 1);
						// 更新本地存储
						saveBookshelf();
						uni.showToast({
							title: '删除成功',
							icon: 'success'
						});
					}
				}, (error) => {
					console.error('删除文件失败:', error);
					uni.showToast({
						title: '删除失败',
						icon: 'none'
					});
				});
			}, (error) => {
				console.error('找不到文件:', error);
				// 如果文件已不存在，仍然从列表中移除
				const index = books.value.findIndex(item => item.path === book.path);
				if (index !== -1) {
					books.value.splice(index, 1);
					saveBookshelf();
					uni.showToast({
						title: '从书架中移除成功',
						icon: 'success'
					});
				}
			});
		} catch (error) {
			console.error('删除书籍时发生错误:', error);
			uni.showToast({
				title: '删除失败: ' + (error.message || JSON.stringify(error)),
				icon: 'none'
			});
		}
	};

	// 页面加载时加载书架数据
	onMounted(() => {
		console.log('页面加载，开始加载书架数据');
		loadBookshelf();
	});
</script>

<style lang="scss">
	@import '/common/common.scss';

	.bookshelf-every {
		width: 100vw;
		height: calc(100vh - 70px);
		background-color: var(--bg-color);
		display: flex;
		flex-wrap: wrap;
		justify-content: flex-start;

		.header {
			display: flex;
			justify-content: space-between;
			align-items: center;
			margin-top: 40px;
			width: 100%;
			height: 30px;
		}

		.book-list {
			width: calc(100vw - 60px);
			height: 500px;
			display: flex;
			margin: auto;
			// background-color: #ff681c;
			margin-top: 20px;
			.book-grid-container{
				display: flex;
				flex-wrap: wrap;
				justify-content: flex-start;
				gap: 20px;
				margin: auto;
			}
		}

		.book-item {
			width: calc(33.33% - 14px);
			display: flex;
			flex-direction: column;
			align-items: center;
			gap: 10px;

			.book-cover {
				width: 100%;
				height: 120px;
				border-radius: 8px;
				box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
			}

			.book-title {
				font-size: 14px;
				color: #ffffff;
				text-align: center;
				width: 100%;
				overflow: hidden;
				text-overflow: ellipsis;
				white-space: nowrap;
			}
		}
	}
</style>